const mongoose = require("mongoose");
const prizeSchema = new mongoose.Schema({
    name: String,
    rate: {
        type: Number, // 数据类型应为 Number
        set: value => parseFloat(value), // 确保传入的是数值
        validate: {
            validator: function (value) {
                return value >= 0 && value <= 100; // 概率应在 0 到 100 之间
            },
            message: '概率必须在 0 到 100 之间'
        }
    },
    number: {
        type: Number, // 数据类型应为 Number
        set: value => parseFloat(value) // 确保传入的是数值
    },
    type: {
        type: Number,
        default: 0
    },
});


prizeSchema.pre('save', async function (next) {
    try {
        // 如果是更新“再抽一次”选项，则跳过验证
        if (this.name === '再抽一次') {
            return next();
        }
        // 计算现有奖品的概率总和（不包括当前文档）
        const totalRate = await this.constructor.aggregate([
            { $match: { _id: { $ne: this._id }, name: { $ne: '再抽一次' } } }, // 排除当前文档
            { $group: { _id: null, totalRate: { $sum: '$rate' } } }
        ]).then(result => result[0]?.totalRate || 0);

        const newTotalRate = totalRate + this.rate;

        if (newTotalRate > 100) {
            throw new Error('所有奖品的概率总和不能超过 100%');
        }

        // 如果概率总和小于 100%，则更新或创建“再抽一次”选项
        if (newTotalRate < 100) {
            const remainingRate = 100 - newTotalRate;
            let anotherChance = await this.constructor.findOne({ name: '再抽一次' });

            if (!anotherChance) {
                anotherChance = new this.constructor({
                    name: '再抽一次',
                    rate: remainingRate,
                    number: 0,
                    type: 0 // 使用特殊类型的标识符表示“再抽一次”
                });
                await anotherChance.save();
            } else {
                anotherChance.rate = remainingRate;
                await anotherChance.save();
            }
        }

        next(); // 不要使用 await next()
    } catch (err) {
        next(err); // 确保错误被传递给 Express 的错误处理器
    }
});

prizeSchema.statics.removePrizeAndAdjustRate = async function (id) {
    return new Promise(async (resolve, rej) => {
        try {
            // 查找并删除指定的奖品
            const deletedPrize = await this.findByIdAndDelete(id);
            if (!deletedPrize) {
                throw new Error('未找到该奖品');
            }

            // 调整概率总和，确保为 100%
            await adjustAnotherChance(this, null); // null 表示不需要加上被删除奖品的概率
            resolve(1)
        } catch (err) {
            rej(err)
            throw err;
        }
    })
};

// 辅助函数：调整“再抽一次”的概率
function adjustAnotherChance(PrizeModel, newTotalRate) {
    return new Promise(async (resolve, rej) => {

        try {
            let totalRate = newTotalRate || await PrizeModel.aggregate([
                { $match: { name: { $ne: '再抽一次' } } },
                { $group: { _id: null, totalRate: { $sum: '$rate' } } }
            ]).then(result => result[0]?.totalRate || 0);


            if (totalRate < 100) {
                const remainingRate = 100 - totalRate;
                let anotherChance = await PrizeModel.findOne({ name: '再抽一次' });

                if (!anotherChance) {
                    anotherChance = new PrizeModel({
                        name: '再抽一次',
                        rate: remainingRate,
                        number: 0,
                        type: 0 // 使用特殊类型的标识符表示“再抽一次”
                    });
                    await anotherChance.save();
                } else {
                    anotherChance.rate = remainingRate;
                    await anotherChance.save();
                }
            }
            resolve(1)
        } catch (err) {
            console.error('Error adjusting total rate:', err);
            rej(err)
            throw err;
        }


    })

}
const prize = mongoose.model("prize", prizeSchema);
module.exports = {
    prize
};
